perm filename ALREC.SAI[AL,HE]15 blob
sn#500996 filedate 1980-03-28 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00006 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 header files & the like
C00004 00003 ! Standard records
C00016 00004 ! data types
C00018 00005 ! operators for expressions
C00023 00006 ! predeclared variables & internal system variables
C00026 ENDMK
C⊗;
COMMENT header files & the like;
IFCR ¬DECLARATION(π) THENC
ENTRY;
BEGIN "ALREC"
REQUIRE "ABBREV.SAI[AL,HE]" SOURCE_FILE;
REQUIRE "MACROS.SAI[AL,HE]" SOURCE_FILE;
REQUIRE "RECAUX.HDR[AL,HE]" SOURCE_FILE;
REQUIRE "REFBTS.DEF[AL,HE]" SOURCE_FILE;
DEFINE ALRECTERNAL=<INTERNAL>;
DEFINE ALRECEND=<END>;
DEFINE ALRECSW = 1;
DEFINE NOARITH = "TRUE";
REQUIRE "ARITH.HDR[AL,HE]" SOURCE_FILE;
ELSEC
REQUIRE "ALREC.REL[AL,HE]" LOAD_MODULE;
DEFINE ALRECEND=< >;
DEFINE ALRECTERNAL=<EXTERNAL>;
DEFINE ALRECSW = 0;
ENDC
! a few constants;
DEFINE INCHES = "2.54";
DEFINE DEGREES = "(π/180.0)";
ALRECTERNAL OWN INTEGER ARRAY PATCH[0:50];
! Standard records ;
DEFINE ALRTYPE(FOO,BAR) "<>" =
< ASSIGNC BAR = CVPS(FOO)&"TYPE";
REDEFINE NHRECS=NHRECS+1;
DEFINE BAR = NHRECS>;
DEFINE ALRCLASS(FOO) "<>" =
< ALRTYPE(FOO);
ALRECTERNAL RECORD_CLASS FOO >;
DEFINE NHRECS=0;
DEFINE REXPR = <RANY>,
RVAR = <RPTR(VARIABLE,EXPRN)>,
RSTMNT = <RPTR(STMNT)>,
RSSS = <RANY>,
RBLK = <RPTR(BLOCK)>,
RTHREAD = <RPTR(THREAD)>;
! Constants. **** Now, record classes defined by ARITH ****;
ALRCLASS (STCONST) (STRING VAL);
ALRCLASS (CHAR_REC) (INTEGER CHAR); ! Mainly used in gobble;
ALRTYPE(V3ECT);
ALRTYPE(ROTN);
ALRTYPE(TRANS);
ALRTYPE(SVAL);
ALRTYPE(TINFO);
ALRTYPE(FRAME);
! expressions;
ALRCLASS (EXPRN) (INTEGER DATATYPE,OP;RCELL ARGS);
! Variables & their attributes;
ALRCLASS (VNODE) (INTEGER INVMARK; RPTR(VALU$) VAL;
RPTR(VNODE) NEXT,OLDVAL; RANY VAR,THREAD);
ALRCLASS (CALC) (INTEGER TYPE; RPTR(CALC) NEXT,NXTCALC,REMCALC;
RANY US,OTHER,BVAR,THREAD);
! type: 1 = rigid, 2 = frame 2;
ALRCLASS (THREAD) (RPTR(VNODE) VALS,DEPRS; RPTR(CALC) CALCS,REMCALCS);
ALRCLASS (LBLVAR) (STRING NAME;INTEGER DATATYPE;RANY BLK;RANY SEMANTICS);
ALRCLASS (STMNT)(RSSS SEMANTICS; RPTR(LBLVAR) STLAB);
ALRCLASS (VARIABLE)(STRING NAME; RANY BLK; INTEGER DATATYPE, OFFSET,
ATTRIBUTES; RPTR(VNODE) PLNVAL, DEPR; RPTR(CALC) CALCS);
! Variable attribute bits follow: ;
BITDEF(REFARG,'2); ! This variable is accessed by "reference";
BITDEF(VALARG,'4); ! This variable is accessed by "value";
! BLK is block in which this variable appears;
ALRCLASS (ARRAYDEF)(STRING NAME; RANY BLK; INTEGER DATATYPE,
OFFSET, ATTRIBUTES, NUMDIMS;
REXPR ARRAY BOUNDS; INTEGER ARRAY BDVALS;
RVAR ARRAY VARS);
ALRCLASS (PROCDEF) (STRING NAME; RANY BLK; INTEGER DATATYPE, OFFSET,
ATTRIBUTES, LAB, NUMARGS; RCELL ARGS; RSTMNT BODY);
! Control structures;
ALRCLASS (PROG) (RPTR(STMNT) CODE);
ALRCLASS (BLOCK) (RCELL CODE,VARS,ARAYS,CMONS,EVTS,PROCS;
STRING BLID; RBLK PARENT);
ALRCLASS (COBLOCK) (RCELL CODE);
ALRCLASS (FORR) (RVAR CONVAR; REXPR INITIAL, STEP, FINAL; RSTMNT BODY);
ALRCLASS (WHIL) (REXPR COND; RSTMNT BODY);
ALRCLASS (UNTL) (REXPR COND; RSTMNT BODY);
ALRCLASS (KASE) (REXPR INDEX; INTEGER RANGE, NSTMNTS;
INTEGER ARRAY LABS; RCELL STMNTS);
ALRCLASS (IFF) (REXPR COND; RSTMNT THN, ELS);
ALRCLASS (PAUSE) (REXPR VAL);
ALRCLASS (PROMPT) (REXPR VAL);
ALRCLASS (PRNT) (REXPR VAL);
ALRCLASS (ABORT) (REXPR VAL);
ALRCLASS (RETRN) (REXPR VAL);
! graph structure manipulators;
ALRCLASS (ASSIGNMENT) (RVAR VAR; REXPR VAL);
ALRCLASS (PAS) (RVAR VAR; REXPR VAL);
ALRCLASS (DEPROACH) (RVAR VAR; REXPR VAL);
ALRCLASS (PVL)(RCELL VL);
ALRCLASS (AFFIX) (RVAR FRAME1,FRAME2,BYVAR;REXPR ATEXP;BOOLEAN RIGID);
ALRCLASS (UNFIX) (RVAR FRAME1,FRAME2);
ALRCLASS (EVDO)(RVAR VAR; INTEGER OP); ! OP = 0 for signal, =1 for wait;
ALRCLASS (DEXPR)(RVAR VAR;REXPR EXPN;RPTR(VALU$) VAL;RVAR TMPVAR);
! This construct is intended as a special kluge to
pass destination expressions on to MOVE statements
& (perhaps) other PASS3 things that need planning
values. VAR is assumed to be a variable whose
value is to be fetched at runtime. If EXPN is
not null, then VAR is probably a temp. In any event,
it is assumed that PASS3 will emit code to compute
EXPN & assign it into VAR before using. VAL
is set up by the simulator & contains the planning
value of VAR. TMPVAR is the same as VAR if VAR is
a temp. The reason for this is that the simulator may
make several passes over the same statement & I
need a way to avoid creating duplicate temps all over
the place.
;
! motion statements and clauses;
ALRCLASS (MOVE$) (RVAR WHAT; REXPR DEST; RCELL CLAUSES; REAL SFAC;
RVAR CF; RPTR(VALU$) CFVAL; RPTR(DEXPR) DEXP);
ALRCLASS (OPERATE) (RVAR WHAT; REXPR DEST; RCELL CLAUSES; REAL SFAC;
RVAR CF; RPTR(VALU$) CFVAL; RPTR(DEXPR) DEXP);
! CF is the controllable frame for this motion statement.
DEXP is the DEXPR that gives the ACTUAL destination for
CF.
**** At present, the program graph is NOT modified
to generate an assignment statement into DFTEMP.
It is assumed that the code generator will
generate code to evaluate the expression &
then poke the value away. WLDMOD will, however,
call CHANGE to give DFTEMP a correct planning value.;
DEFINE MAX_VISE_OPENING = "4.6875";
ALRCLASS (CENTER) (RVAR CF;RCELL CLAUSES);
ALRCLASS (STOP) (RVAR CF);
ALRCLASS (CMON) (REXPR CONDITION; RSTMNT CONCLUSION;
INTEGER OFFSET,FLAGS);
BITDEF(DEFER,'1); ! set if deferred cmon;
BITDEF(W_ARM,'2); ! set if yellow arm;
ALRCLASS (CMABLE) (RPTR(CMON,LBLVAR) WHAT;INTEGER FLAG);
! (FLAG = TRUE) => enable, else disable;
ALRCLASS (DURATION) (REXPR TIME; INTEGER TIME_RELN);
! Note: the time relations are the following:
0 no relation given
1 > (that is, a lower bound)
2 < (that is, an upper bound)
3 = (that is, an exact bound)
;
ALRCLASS (VIA) (REXPR PLACE,VELOC; RPTR(DURATION) TIME;
RPTR(CMON,EVDO) CODE;RPTR(DEXPR) ACTPLACE);
! ACTPLACE gives where this VIA must actually go thru. ;
ALRCLASS (APPROACH) (REXPR THRU; RPTR(CMON,EVDO) CODE;
RPTR(DEXPR) ACTPLACE);
ALRCLASS (DEPARTURE) (REXPR THRU; RPTR(CMON,EVDO) CODE;
RPTR(DEXPR) ACTPLACE);
ALRCLASS (VELOCITY) (REXPR VELOC);
ALRCLASS (F_FRAME) (REXPR FRAME; INTEGER C_SYS);
ALRCLASS (FORCE) (REXPR DIRECT, VAL; INTEGER TYPE,REL; RPTR(F_FRAME) F_F);
! Type: Torque = False
Force = True
Rel: < = SIGLT
≥ = SIGGE;
ALRCLASS (STIFF) (REXPR K,G; RPTR(F_FRAME) F_F);
ALRCLASS (GATHER) (INTEGER BITS);
! The following bits are used during calls to the force sensing system;
DEFINE YELARM = '1; ! Yellow arm;
DEFINE BLUARM = '4; ! Blue arm;
DEFINE FTABLE = '400; ! Force trans (C) in table coordinates;
DEFINE FHAND = '0; ! " " " " hand coordinate system;
DEFINE XFORCE = '0; ! Force along X direction of C;
DEFINE YFORCE = '1000; ! " " Y " " ";
DEFINE ZFORCE = '2000; ! " " Z " " ";
DEFINE XMOMENT = '3000; ! Moment about X direction of C;
DEFINE YMOMENT = '4000; ! " " Y " " ";
DEFINE ZMOMENT = '5000; ! " " Z " " ";
DEFINE FSTOP = '10000; ! In addition to starting cmon, stop arm;
DEFINE SIGMAG = '20000; ! Test only magnitude of forces;
DEFINE SIGGE = '100000; ! Start cmon if force ≥ specified value;
DEFINE SIGLT = '0; ! " " " " < " ";
ALRCLASS (SETBASE) (INTEGER VAL); ! These are temporary hacks for JKS;
ALRCLASS (WRIST) (REXPR K,G); ! so he can debug the force wrist;
ALRCLASS (OPENING) (REXPR VAL);
ALRCLASS (WOBBLE) (REXPR VAL);
ALRCLASS (S_FAC) (REXPR VAL);
ALRCLASS (NNULL) (INTEGER FLAG);
ALRCLASS (RTMOVE) (INTEGER FLAG); ! use experimental runtime trajectory
calculator -- for Shahid;
ALRCLASS (SW_TIME) (REXPR VAL); ! for vise;
ALRCLASS (CW) (INTEGER FLAG); ! for driver;
ALRCLASS (ERROR) (REXPR BITS; RSTMNT BODY); ! Error handler for motions;
ALRCLASS (RETRY) (INTEGER DUMMY); ! for software retries from error handlers;
ALRTYPE (TO); ! for alternative MOVE syntax;
! Totally miscellaneous things;
ALRCLASS (COMMNT) (RANY HESAYS);
ALRCLASS (NOTE) (RPTR(STCONST) HESAYS);
ALRCLASS (NOTE1) (RPTR(STCONST) HESAYS);
ALRCLASS (NOTE2) (RPTR(STCONST) HESAYS);
ALRTYPE (DEBUG); ! for debugging the gobbler;
! data types;
DEFINE DEFDTYPE(MNE,XXX) "<>" = <
REDEFINE NDTYPES=NDTYPES+1;
ASSIGNC XXX = CVPS(MNE)&"_DTYPE";
DEFINE XXX = NDTYPES>;
DEFINE NDTYPES=-1;
DEFDTYPE(INVALID); ! 0 is invalid;
DEFDTYPE(SVAL); ! scalar;
DEFDTYPE(V3ECT); ! 3 vector;
DEFDTYPE(ROTN); ! rotation;
DEFDTYPE(TRANS); ! transform matrix;
DEFDTYPE(FRAME); ! frame;
DEFDTYPE(ARAY); ! array;
DEFDTYPE(PROC); ! procedure;
DEFDTYPE(REF); ! call by referemce;
DEFDTYPE(VAL); ! call by value;
DEFDTYPE(EVENT); ! an "event" variable;
! note: Labels get loaded up with the semantics of the thing
pointed to.
;
DEFDTYPE(STMLAB); ! statement label;
DEFDTYPE(OMNLAB); ! on-monitor label;
! operators for expressions;
IFCR ALRECSW THENC
DEFINE DEFOP(MNE,XXX,YYY) "<>" = <
REDEFINE NOPS=NOPS+1;
ASSIGNC XXX = CVPS(MNE)&"_OP";
ASSIGNC YYY = """"&CVPS(MNE)&"""";
YYY,
DEFINE XXX = NOPS>;
PRELOAD_WITH
ELSEC
DEFINE DEFOP(MNE,XXX) "<>" = <
REDEFINE NOPS=NOPS+1;
ASSIGNC XXX = CVPS(MNE)&"_OP";
DEFINE XXX = NOPS>;
ENDC
DEFINE OPBRK(MXID,MNID,XXX) "<>" = <
ASSIGNC XXX = "MAX_"&CVPS(MXID)&"_OP";
DEFINE XXX = NOPS;
ASSIGNC XXX = "MIN_"&CVPS(MNID)&"_OP";
DEFINE XXX = NOPS+1>;
! This list updated 6/30/75 by RF & 7/25/76, 3/2/78 & 5/28/78 by ARG;
DEFINE NOPS=-1; ! Return nothing;
DEFOP(INVALID);
DEFOP(AREF); ! array reference - returns ?;
DEFOP(CALL); ! procedure call - returns ?;
DEFOP(NO); ! no-op;
OPBRK(NO,SVAL); ! Return scalars;
DEFOP(SSBRTN); ! arithmetic functions: sqrt,sin,cos,asin,acos,atan2,log,exp;
DEFINE SQRT_OP = "1", SIN_OP = "2", COS_OP = "3", TAN_OP = "4",
ASIN_OP = "5", ACOS_OP = "6", ATAN2_OP = "7",
LOG_OP = "8", EXP_OP = "9", TIME_OP = "10";
DEFOP(SCALRD); ! reads in scalar from console;
DEFOP(QUERY); ! reads in boolean from console;
DEFOP(SABS); ! |s| (absolute value);
DEFOP(SADD); ! s+s;
DEFOP(SSUB); ! s-s;
DEFOP(SNEG); ! -s;
DEFOP(SMUL); ! s*s;
DEFOP(SDIV); ! s/s;
DEFOP(SEXP); ! s↑s (not in runtime);
DEFOP(MAX); ! s MAX s;
DEFOP(MIN); ! s MIN s;
DEFOP(INT); ! INT s;
DEFOP(DIV); ! INT(s/s);
DEFOP(MOD); ! s MOD s;
DEFOP(SLT); ! S<S;
DEFOP(SEQ); ! S=S;
DEFOP(SLE); ! S≤S;
DEFOP(SGE); ! S≥S;
DEFOP(SNE); ! S≠S;
DEFOP(SGT); ! S>S;
DEFOP(AND); ! S∧S;
DEFOP(OR); ! S∨S;
DEFOP(XOR); ! S⊗S;
DEFOP(EQV); ! S≡S;
DEFOP(NOT); ! ¬S;
DEFOP(VMAGN); ! |v|;
DEFOP(VDOT); ! v.v;
DEFOP(RMAGN); ! rotation angle of r;
OPBRK(SVAL,V3ECT); ! Return vectors;
DEFOP(VMAKE); ! vector(s,s,s);
DEFOP(SVMUL); ! s*v;
DEFOP(VSDIV); ! v/s;
DEFOP(VADD); ! v+v;
DEFOP(VSUB); ! v-v;
DEFOP(VCROSS); ! v*v;
DEFOP(RVMUL); ! r*v;
DEFOP(TVMUL); ! t*v;
DEFOP(UVECT); ! v/magn(v);
DEFOP(AXIS); ! rotation axis of r;
DEFOP(POS); ! position part of a trans;
OPBRK(V3ECT,ROTN); ! Return rotns;
DEFOP(AXW_ROTN); ! rotation of s radians about v;
DEFOP(ORIENT); ! rotation part of t;
DEFOP(RRMUL); ! r*r;
OPBRK(ROTN,TRANS); ! Return transes;
DEFOP(TMAKE); ! trans(r,v);
DEFOP(CONSTR); ! constr(v,v,v) (origin,x-axis,xy-plane);
DEFOP(FTOF); ! f → f;
DEFOP(TVADD); ! t+v;
DEFOP(TVSUB); ! t-v;
DEFOP(TTMUL); ! t*t;
DEFOP(TINVRT); ! inverse(t);
DEFOP(DEPR); ! deproach(f);
OPBRK(TRANS,FRAME); ! Return frames;
DEFOP(FMAKE); ! frame(R,v);
DEFOP(TFMAKE); ! frame(T);
OPBRK(FRAME,LAST);
DEFOP(LAST); ! Never return;
IFCR ALRECSW THENC
"INVALID";INTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1]; ! Used by ALPRIN;
ELSEC
EXTERNAL STRING ARRAY OP_MNE[0:LAST_OP+1];
ENDC
! predeclared variables & internal system variables;
EXTERNAL RCLASS DEFID(STRING NAME; RANY VAL; RPTR(DEFID) NEXT);
EXTERNAL RPTR(DEFID) SYSIDS;
IFCR ALRECSW THENC
DEFINE PDV(ID,PID,HDT,OFFST,INID) "<>" =
<
INTERNAL RPTR(VARIABLE) ID;
ASSIGNC INID="INI_"&CVPS(ID);
PROCEDURE INID;
BEGIN
RPTR(DEFID) D;
ID←NEW_RECORD(VARIABLE);
VARIABLE:NAME[ID] ← "PID";
VARIABLE:DATATYPE[ID] ← HDT;
VARIABLE:OFFSET[ID] ← OFFST;
D ← NEW_RECORD(DEFID);
DEFID:NAME[D] ← "PID";
DEFID:VAL[D] ← ID;
DEFID:NEXT[D] ← SYSIDS;
SYSIDS ← D
END;
REQUIRE INID INITIALIZATION>;
ELSEC
DEFINE PDV(ID,PID,HDT,OFFST) "<>" =
< EXTERNAL RPTR(VARIABLE) ID >;
ENDC
PDV(YARM,YARM,FRAME_DTYPE,'0);
PDV(YHAND,YHAND,SVAL_DTYPE,'1);
PDV(BARM,BARM,FRAME_DTYPE,'2);
PDV(BHAND,BHAND,SVAL_DTYPE,'3);
PDV(YDEPROACH,YDEPROACH,FRAME_DTYPE,'4);
PDV(BDEPROACH,BDEPROACH,FRAME_DTYPE,'5);
PDV(ARRIVAL,ARRIVAL,EVENT_DTYPE,0); ! Never use the offset;
PDV(VISE,VISE,SVAL_DTYPE,'6);
PDV(FIXED_JAW,FIXED_JAW,FRAME_DTYPE,'7);
PDV(MOVING_JAW,MOVING_JAW,FRAME_DTYPE,'10);
PDV(VISE_OPENING,.VISE_OPENING,TRANS_DTYPE,'11);
PDV(DRIVER,DRIVER,SVAL_DTYPE,0); ! Never use the offset;
PDV(DR_GRASP,DRIVER_GRASP,FRAME_DTYPE,'12);
PDV(DR_TIP,DRIVER_TIP,FRAME_DTYPE,'13);
PDV(DR_TRANS,.DRIVER_TRANS,TRANS_DTYPE,'14);
PDV(DR_TURNS,DRIVER_TURNS,SVAL_DTYPE,'15);
PDV(BA_ERR,BARM_ERROR,SVAL_DTYPE,'16);
PDV(BH_ERR,BHAND_ERROR,SVAL_DTYPE,'17);
PDV(YA_ERR,YARM_ERROR,SVAL_DTYPE,'20);
PDV(YH_ERR,YHAND_ERROR,SVAL_DTYPE,'21);
PDV(VI_ERR,VISE_ERROR,SVAL_DTYPE,'22);
PDV(DR_ERR,DRIVER_ERROR,SVAL_DTYPE,'23);
PDV(SPEED_FACTR,SPEED_FACTR,SVAL_DTYPE,'24);
ALRECEND